home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 1.toast / Sample Code / Graphics 2D / QuickDraw FX / FX.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-28  |  19.3 KB  |  658 lines  |  [TEXT/CWIE]
  1. /*
  2.     File:        FX.c
  3.  
  4.     Contains:    
  5.  
  6.     Written by: EL    
  7.  
  8.     Copyright:    Copyright © 1992-1999 by Apple Computer, Inc., All Rights Reserved.
  9.  
  10.                 You may incorporate this Apple sample source code into your program(s) without
  11.                 restriction. This Apple sample source code has been provided "AS IS" and the
  12.                 responsibility for its operation is yours. You are not permitted to redistribute
  13.                 this Apple sample source code as "Apple sample source code" after having made
  14.                 changes. If you're going to re-distribute the source, we require that you make
  15.                 it clear in the source that the code was descended from Apple sample source
  16.                 code, but that you've made changes.
  17.  
  18.     Change History (most recent first):
  19.                 08/2000        JM                Carbonized, non-Carbon code is commented out
  20.                                             for demonstration purposes.
  21.                 7/13/1999    KG                Updated for Metrowerks Codewarror Pro 2.1
  22.                 
  23.  
  24. */
  25.  
  26. #include "FX.h"
  27.  
  28.  
  29. long drawFXImage()
  30. {
  31.     int        exampleNumber, exampleItem;
  32.     Rect    rect, rect2;
  33.     Rect    outlineRect;
  34.     long    startTicks, endTicks;
  35.     Point    point = { 0, 0 };
  36.     Rect    frame;
  37.     Rect    windowRect, gWorldRect;
  38.     
  39.     /*SetRect( &rect, (*gWindow).portRect.right - (*gGWorld).portRect.right - 20, 37,
  40.                 (*gWindow).portRect.right - 20, 37 + (*gGWorld).portRect.bottom );*/
  41.     GetPortBounds(GetWindowPort(gWindow), &windowRect);
  42.     GetPortBounds(gGWorld, &gWorldRect);
  43.     SetRect( &rect, windowRect.right - gWorldRect.right - 20, 37,
  44.                 windowRect.right - 20, 37 + gWorldRect.bottom );
  45.     
  46.     outlineRect = rect;
  47.     InsetRect( &outlineRect, -5, -5 );
  48.     drawDeepBox( &outlineRect );
  49.     
  50.     frame = rect;
  51.     
  52.     if (settings.bItem == 1)
  53.     {
  54.         ForeColor( whiteColor );
  55.         PaintRect( &rect );
  56.     }
  57.     else if (settings.bItem == 2)
  58.     {
  59.         ForeColor( blackColor );
  60.         PaintRect( &rect );
  61.     }
  62.     else
  63.     {
  64.         rect2 = rect;
  65.         
  66.         rect2.right = (rect2.right - rect2.left) / 2 + rect2.left;
  67.         ForeColor( whiteColor );
  68.         PaintRect( &rect2 );
  69.         
  70.         rect2.left = rect2.right;
  71.         rect2.right = rect.right;
  72.         ForeColor( blackColor );
  73.         PaintRect( &rect2 );
  74.     }
  75.  
  76.     ForeColor( blackColor );
  77.     BackColor( whiteColor );
  78.     
  79.     exampleNumber = gCurrentExample / 10;
  80.     exampleItem = gCurrentExample % 10;
  81.     
  82.     startTicks = TickCount();
  83.     
  84.     if (exampleNumber == 1)
  85.         transferExample( &rect, exampleItem );
  86.     else if (exampleNumber == 2)
  87.         arithmeticExample( &rect, exampleItem );
  88.     else if (exampleNumber == 3)
  89.         ditherExample( &rect, exampleItem );
  90.     else if (exampleNumber == 4)
  91.         colorizationExample( &rect, exampleItem );
  92.     else if (exampleNumber == 5)
  93.         mappingExample( &rect, exampleItem );
  94.     else if (exampleNumber == 6)
  95.         paintBucketExample( &rect, exampleItem, point );
  96.     else if (exampleNumber == 7)
  97.         lassoToolExample( &rect, exampleItem, &frame );
  98.     else if (exampleNumber == 8)
  99.         pixelAverageExample( &rect, exampleItem );
  100.     else if (exampleNumber == 9)
  101.         customExample( &rect, exampleItem );
  102.         
  103.     endTicks = TickCount();
  104.     
  105.     return (endTicks - startTicks);
  106. }
  107.  
  108. void transferExample( Rect *rect, int item )
  109. {
  110.     int        transferMode;
  111.     
  112.     resetItems();
  113.     settings.tItem = item;
  114.     
  115.     transferMode = setTransferMode( item );
  116.     
  117.     /*CopyBits( (BitMap *)(*(*gGWorld).portPixMap), &gWindow->portBits,
  118.                 &(**(*gGWorld).portPixMap).bounds, rect, transferMode, nil );*/
  119.     CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  120.                 &((**(GetPortPixMap(gGWorld))).bounds), rect, transferMode, nil );
  121. }
  122.  
  123. int setTransferMode(int     item )
  124. {
  125.     item--;
  126.     return item;
  127. }
  128.  
  129. void arithmeticExample( Rect *rect, int item )
  130. {
  131.     int            arithmeticMode;
  132.     RGBColor    color;
  133.     
  134.     resetItems();
  135.     settings.aItem = item;
  136.     
  137.     arithmeticMode = setArithmeticMode( item );
  138.     
  139.     /*CopyBits( (BitMap *)(*(*gGWorld).portPixMap), &gWindow->portBits,
  140.                 &(**(*gGWorld).portPixMap).bounds, rect, arithmeticMode, nil );*/
  141.     CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  142.                 &((**(GetPortPixMap(gGWorld))).bounds), rect, arithmeticMode, nil );
  143.                 
  144.     color.red = color.green = color.blue = 0;
  145.     OpColor( &color );
  146. }
  147.  
  148. int setArithmeticMode(int item)
  149. {
  150.     RGBColor    color;
  151.     
  152.     if (item <= 4)
  153.         item = 31 + item;
  154.     else if (item == 9)
  155.         item = transparent;
  156.     else
  157.         item = 32 + item;
  158.     
  159.     color.red = color.green = color.blue = 0xffff / 2;
  160.     OpColor( &color );
  161.     
  162.     return item;
  163. }
  164.  
  165. void colorizationExample(Rect *rect, int item )
  166. {
  167.     int            i;
  168.     Rect        srcRect, dstRect;
  169.     RGBColor    color;
  170.     
  171.     resetItems();
  172.     settings.cItem = item;
  173.     
  174.     //srcRect = (**(*gGWorld).portPixMap).bounds;
  175.     srcRect = (**(GetPortPixMap(gGWorld))).bounds;
  176.     srcRect.right = srcRect.left + (srcRect.right - srcRect.left) / 3;
  177.     
  178.     dstRect = *rect;
  179.     dstRect.right = dstRect.left + (dstRect.right - dstRect.left) / 3;
  180.     
  181.     for (i = 0; i < 3; i++)
  182.     {
  183.         if (item == 1)
  184.         {
  185.             ForeColor( blackColor );
  186.             BackColor( whiteColor );
  187.         }    
  188.         else if (item == 2)
  189.         {
  190.             ForeColor( whiteColor );
  191.             BackColor( blackColor );
  192.         }
  193.         else
  194.         {
  195.             color.red = color.green = color.blue = 0;
  196.         
  197.             if (i == 0)
  198.                 color.red = 0xffff;
  199.             else if (i == 1)
  200.                 color.green = 0xffff;
  201.             else if (i == 2)
  202.                 color.blue = 0xffff;
  203.             
  204.             if (item == 3)
  205.             {
  206.                 RGBForeColor( &color );
  207.                 BackColor( whiteColor );
  208.             }
  209.             else
  210.             {
  211.                 RGBBackColor( &color );
  212.                 ForeColor( blackColor );
  213.             }
  214.         }
  215.                 
  216.         /*CopyBits( (BitMap *)(*(*gGWorld).portPixMap), &gWindow->portBits,
  217.                 &srcRect, &dstRect, srcCopy, nil );*/
  218.         CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  219.                 &srcRect, &dstRect, srcCopy, nil );
  220.                 
  221.         OffsetRect( &srcRect, srcRect.right - srcRect.left, 0 );
  222.         OffsetRect( &dstRect, dstRect.right - dstRect.left, 0 );
  223.     }
  224. }
  225.  
  226. void ditherExample(Rect    * rect,int item )
  227. {
  228.     #pragma unused(rect)
  229.     int        ditherMode;
  230.     
  231.     /* This function shows an example of using copybits with the dithering. */
  232.     
  233.     resetItems();
  234.     settings.dItem = item;
  235.     
  236.     ditherMode = setDitherMode( item );
  237.     
  238.     /*CopyBits( (BitMap *)(*(*gGWorld).portPixMap), &gWindow->portBits,
  239.                 &(**(*gGWorld).portPixMap).bounds, rect, srcCopy + ditherMode, nil );*/
  240.     CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  241.                 &(**(GetPortPixMap(gGWorld))).bounds, rect, srcCopy + ditherMode, nil );
  242. }
  243.  
  244. int setDitherMode(int item)
  245. {
  246.     if (item == 1)
  247.         return 0;
  248.     else
  249.         return ditherCopy;
  250. }
  251.  
  252. void mappingExample(Rect * rect, int    item )
  253. {
  254.     int            i;
  255.     GWorldPtr    gworld;
  256.     CTabHandle    ictable;
  257.     Rect        tempRect1;
  258.     
  259.     resetItems();
  260.     settings.mItem = item;
  261.     
  262.     if (item == 1)
  263.         /*CopyBits( (BitMap *)(*(*gGWorld).portPixMap), &gWindow->portBits,
  264.             &(**(*gGWorld).portPixMap).bounds, rect, srcCopy, nil );*/
  265.         CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  266.                 &((**(GetPortPixMap(gGWorld))).bounds), rect, srcCopy, nil );
  267.     else if (item == 2)
  268.     {
  269.         ColorSearchUPP searchProcUPP=NewColorSearchProc(searchProc);
  270.         AddSearch(searchProcUPP);
  271.         
  272.         /*CopyBits( (BitMap *)(*(*gGWorld).portPixMap), &gWindow->portBits,
  273.             &(**(*gGWorld).portPixMap).bounds, rect, srcCopy, nil );*/
  274.         CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  275.                 &((**(GetPortPixMap(gGWorld))).bounds), rect, srcCopy, nil );
  276.         
  277.         DelSearch(searchProcUPP);
  278.     }
  279.     else if (item == 3)
  280.     {
  281.         //NewGWorld( &gworld, 8, &(*gGWorld).portRect, GetCTable( 8 + 64 ), nil, 0 );
  282.         NewGWorld( &gworld, 8, GetPortBounds(gGWorld, &tempRect1), GetCTable( 8 + 64 ), nil, 0 );
  283.         
  284.         /*CopyBits( (BitMap *)(*(*gGWorld).portPixMap), (BitMap *)(*(*gworld).portPixMap),
  285.                     &(**(*gGWorld).portPixMap).bounds, &(**(*gworld).portPixMap).bounds,
  286.                     srcCopy, nil );*/
  287.         CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), (BitMap *)(*(GetPortPixMap(gworld))),
  288.                     &((**(GetPortPixMap(gGWorld))).bounds), &((**(GetPortPixMap(gworld))).bounds), 
  289.                     srcCopy, nil );
  290.         
  291.         ictable = GetCTable( 8 );
  292.         
  293.         /*for (i = 0; i <= (**(**(*gworld).portPixMap).pmTable).ctSize; i++)
  294.             (**(**(*gworld).portPixMap).pmTable).ctTable[i].rgb =
  295.                     (**ictable).ctTable[255 - i].rgb;
  296.         
  297.         (**(**(*gworld).portPixMap).pmTable).ctSeed = 67;
  298.     //            (**(**(*(CGrafPtr)gWindow).portPixMap).pmTable).ctSeed; 
  299.         
  300.         CopyBits( (BitMap *)(*(*gworld).portPixMap), &gWindow->portBits,
  301.             &(**(*gworld).portPixMap).bounds, rect, srcCopy, nil );*/
  302.         
  303.         for (i = 0; i <= (**(**(GetPortPixMap(gworld))).pmTable).ctSize; i++)
  304.             (**(**(GetPortPixMap(gworld))).pmTable).ctTable[i].rgb =
  305.                     (**ictable).ctTable[255 - i].rgb;
  306.         
  307.         (**(**(GetPortPixMap(gworld))).pmTable).ctSeed = 67;
  308.         
  309.         CopyBits( (BitMap *)(*(GetPortPixMap(gworld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  310.             &(**(GetPortPixMap(gworld))).bounds, rect, srcCopy, nil );
  311.         
  312.         DisposeGWorld( gworld );
  313.     }
  314. }
  315.  
  316. pascal Boolean searchProc( RGBColor    * color, long        *position )
  317. {
  318.     #pragma unused(position)
  319.     (*color).red = 0;
  320.     
  321.     return false;
  322. }
  323.  
  324. void paintBucketExample(Rect *rect, int exampleItem, Point point )
  325. {
  326.     #pragma unused(exampleItem)
  327.     GrafPtr     mask;
  328.     Point        newPoint;
  329.     GWorldPtr    gworld;
  330.     Rect        tempRect1;
  331.     
  332.     resetItems();
  333.  
  334.     newPoint.h = point.h - 20;
  335.     newPoint.v = point.v - 37;
  336.  
  337.     /*if (newPoint.h < 0 || newPoint.v < 0 ||
  338.         newPoint.h > ((**(*gGWorld).portPixMap).bounds.right - (**(*gGWorld).portPixMap).bounds.left) ||
  339.         newPoint.v > ((**(*gGWorld).portPixMap).bounds.bottom - (**(*gGWorld).portPixMap).bounds.top))
  340.         return;*/
  341.     tempRect1 = (**(GetPortPixMap(gGWorld))).bounds;
  342.     if (newPoint.h < 0 || newPoint.v < 0 ||
  343.         newPoint.h > tempRect1.right - tempRect1.left ||
  344.         newPoint.v > tempRect1.bottom - tempRect1.top)
  345.         return;
  346.         
  347.     //mask = CreateGrafPort( &(*gGWorld).portRect );
  348.     mask = CreateGrafPort(GetPortBounds(gGWorld, &tempRect1));
  349.     
  350.     ForeColor( redColor );
  351.     MoveTo( point.h - 2, point.v );
  352.     LineTo( point.h + 2, point.v );
  353.     MoveTo( point.h, point.v - 2 );
  354.     LineTo( point.h, point.v + 2 );
  355.  
  356.     ForeColor( blackColor );
  357.  
  358.     //NewGWorld( &gworld, 8, &(*gGWorld).portRect, GetCTable( 8 + 64 ), nil, 0 );
  359.     NewGWorld( &gworld, 8, GetPortBounds(gGWorld, &tempRect1), GetCTable( 8 + 64 ), nil, 0 );
  360.         
  361.     /*CopyBits( (BitMap *)(*(*gGWorld).portPixMap), (BitMap *)(*(*gworld).portPixMap),
  362.                     &(**(*gGWorld).portPixMap).bounds, &(**(*gworld).portPixMap).bounds,
  363.                     srcCopy, nil );*/
  364.     CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), (BitMap *)(*(GetPortPixMap(gworld))),
  365.                     &((**(GetPortPixMap(gGWorld))).bounds), &((**(GetPortPixMap(gworld))).bounds), 
  366.                     srcCopy, nil );
  367.                     
  368. //    GetGWorld( ¤tPort, ¤tDevice );
  369. //    SetGWorld( gworld, nil );
  370.     
  371.     /*SeedCFill( (BitMap *)(*(*gworld).portPixMap), &mask->portBits,
  372.                 &(**(*gworld).portPixMap).bounds, &mask->portRect,
  373.                 newPoint.h, newPoint.v, nil, 0 );*/
  374.     SeedCFill( (BitMap *)(*(GetPortPixMap(gworld))), GetPortBitMapForCopyBits(mask),
  375.                 &((**(GetPortPixMap(gworld))).bounds), GetPortBounds(mask, &tempRect1),
  376.                 newPoint.h, newPoint.v, nil, 0 );
  377. //    SetGWorld( currentPort, currentDevice );
  378.     
  379.     /*CopyMask( (BitMap *)(*(*gworld).portPixMap), &mask->portBits, &gWindow->portBits,
  380.                 &(**(*gworld).portPixMap).bounds, &mask->portRect, rect );*/
  381.     CopyMask( (BitMap *)(*(GetPortPixMap(gworld))), GetPortBitMapForCopyBits(mask), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  382.                 &(**(GetPortPixMap(gworld))).bounds, GetPortBounds(mask, &tempRect1), rect );
  383.     
  384.     DisposeGrafPort( mask );
  385. }
  386.  
  387. void lassoToolExample(Rect    * rect, int    exampleItem,Rect *frame )
  388. {
  389.     #pragma unused(exampleItem,frame)
  390.     GrafPtr     mask;
  391.     RGBColor    color;
  392.     CGrafPtr    currentPort;
  393.     GDHandle    currentDevice;
  394.     Rect        tempRect1;
  395.     
  396.     pascal Boolean matchProc();
  397.     
  398.     resetItems();
  399.  
  400.     //mask = CreateGrafPort( &(*gGWorld).portRect );
  401.     mask = CreateGrafPort(GetPortBounds(gGWorld, &tempRect1));
  402.  
  403.     GetGWorld( ¤tPort, ¤tDevice );
  404.     SetGWorld( gGWorld, nil );
  405.     
  406.     color.red = color.green = color.blue = 0;
  407.     
  408.     /*CalcCMask( (BitMap *)(*(*gGWorld).portPixMap), &mask->portBits,
  409.                 &(**(*gGWorld).portPixMap).bounds, &mask->portRect,
  410.                 &color, NewColorSearchProc(matchProc), 0 );*/
  411.     CalcCMask( (BitMap *)(*(GetPortPixMap(gGWorld))),GetPortBitMapForCopyBits(mask),
  412.                 &(**(GetPortPixMap(gGWorld))).bounds, GetPortBounds(mask, &tempRect1),
  413.                 &color, NewColorSearchProc(matchProc), 0 );
  414.     
  415.     
  416.     SetGWorld( currentPort, currentDevice );
  417.     
  418.     /*CopyMask( (BitMap *)(*(*gGWorld).portPixMap), &mask->portBits, &gWindow->portBits,
  419.                 &(**(*gGWorld).portPixMap).bounds, &mask->portRect, rect );*/
  420.     CopyMask( (BitMap *)(*(GetPortPixMap(gGWorld))), GetPortBitMapForCopyBits(mask), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  421.                 &(**(GetPortPixMap(gGWorld))).bounds, GetPortBounds(mask, &tempRect1), rect );
  422.                 
  423. /*
  424.     bounds = *frame;
  425.     OffsetRect( &bounds, -bounds.left, -bounds.top );
  426.     
  427.     mask = CreateGrafPort( &bounds );
  428.  
  429.     GetGWorld( ¤tPort, ¤tDevice );
  430.     SetGWorld( gGWorld, nil );
  431.     
  432.     color.red = color.green = color.blue = 0;
  433.     
  434.     CalcCMask( (BitMap *)(*(*gGWorld).portPixMap), &mask->portBits,
  435.                 &bounds, &mask->portRect, &color, matchProc, 0 );
  436.                 
  437.     SetGWorld( currentPort, currentDevice );
  438.         
  439.     CopyMask( (BitMap *)(*(*gGWorld).portPixMap), &mask->portBits, &gWindow->portBits,
  440.                 &bounds, &mask->portRect, frame );
  441. */
  442.     
  443.     DisposeGrafPort( mask );
  444. }
  445.  
  446. pascal Boolean matchProc(RGBColor *color, long        *position )
  447. {    
  448.     GDHandle    currDevice;
  449.     MatchRec    *matchInfo;
  450.     
  451.     currDevice = GetGDevice();
  452.     matchInfo = (MatchRec *)(**currDevice).gdRefCon;
  453.  
  454.     if (matchInfo->red == color->red && matchInfo->green == color->green &&
  455.         matchInfo->blue == color->blue)
  456.         *position = 0;
  457.     else
  458.         *position = 1;
  459.         
  460.     return true;
  461. }
  462.  
  463. void pixelAverageExample(Rect    *rect, int     item )
  464. {
  465.     #pragma unused(item)
  466.     Rect        bounds;
  467.     GWorldPtr    gworld;
  468.     GWorldPtr    source;
  469.     Rect        tempRect1;
  470.     
  471.     resetItems();
  472.     
  473.     /* Create 8-bit gworld from 32-bit original. */
  474.     
  475.     //NewGWorld( &source, 8, &(*gGWorld).portRect, GetCTable( 8 + 64 ), nil, 0 );
  476.     NewGWorld( &source, 8, GetPortBounds(gGWorld, &tempRect1), GetCTable( 8 + 64 ), nil, 0 );
  477.     /*CopyBits( (BitMap *)(*(*gGWorld).portPixMap), (BitMap *)(*(*source).portPixMap),
  478.             &(**(*gGWorld).portPixMap).bounds, &(**(*source).portPixMap).bounds,
  479.             srcCopy, nil );*/
  480.     CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), (BitMap *)(*(GetPortPixMap(source))),
  481.                     &((**(GetPortPixMap(gGWorld))).bounds), &((**(GetPortPixMap(source))).bounds), 
  482.                     srcCopy, nil );
  483.     
  484.     /* Create another 8-bit gworld at quarter size of original. */
  485.         
  486.     /*SetRect( &bounds, 0, 0, (*gGWorld).portRect.right / 4,
  487.                 (*gGWorld).portRect.bottom / 4 );*/
  488.                 
  489.     GetPortBounds(gGWorld, &tempRect1);
  490.     SetRect( &bounds, 0, 0, tempRect1.right / 4,
  491.                 tempRect1.bottom / 4);
  492.     
  493.     NewGWorld( &gworld, 8, &bounds, GetCTable( 8 + 64 ), nil, 0 );
  494.  
  495.     /* Copy the 8-bit original to 8-bit quarter image without pixel averaging. */
  496.     
  497.     //bounds = (*source).portRect;
  498.     GetPortBounds(source, &bounds);
  499.     
  500.     /*CopyBits( (BitMap *)(*(*source).portPixMap), (BitMap *)(*(*gworld).portPixMap),
  501.             &(**(*source).portPixMap).bounds, &(**(*gworld).portPixMap).bounds,
  502.             srcCopy, nil );*/
  503.     CopyBits( (BitMap *)(*(GetPortPixMap(source))), (BitMap *)(*(GetPortPixMap(gworld))),
  504.                     &((**(GetPortPixMap(source))).bounds), &((**(GetPortPixMap(gworld))).bounds), 
  505.                     srcCopy, nil );
  506.     
  507.     /* Copy the quarter image to screen. */
  508.     
  509.     OffsetRect( &bounds, 20, 37 );
  510.     /*CopyBits( (BitMap *)(*(*gworld).portPixMap), &(*gWindow).portBits,
  511.             &(**(*gworld).portPixMap).bounds, &bounds, srcCopy, nil );*/
  512.     CopyBits( (BitMap *)(*(GetPortPixMap(gworld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  513.             &(**(GetPortPixMap(gworld))).bounds, &bounds, srcCopy, nil );
  514.     
  515.     /* Now, copy the 8-bit original to 8-bit quarter image with pixel averaging. */
  516.     
  517.     //bounds = (*source).portRect;
  518.     GetPortBounds(source, &bounds);
  519.     
  520.     /*CopyBits( (BitMap *)(*(*source).portPixMap), (BitMap *)(*(*gworld).portPixMap),
  521.             &(**(*source).portPixMap).bounds, &(**(*gworld).portPixMap).bounds,
  522.             srcCopy + ditherCopy, nil );*/
  523.     CopyBits( (BitMap *)(*(GetPortPixMap(source))), (BitMap *)(*(GetPortPixMap(gworld))),
  524.                     &((**(GetPortPixMap(source))).bounds), &((**(GetPortPixMap(gworld))).bounds), 
  525.                     srcCopy + ditherCopy, nil );
  526.     
  527.     /* Finally, copy pixel averaged quarter image to screen. */
  528.             
  529.     OffsetRect( &bounds, (*rect).left, (*rect).top );
  530.     /*CopyBits( (BitMap *)(*(*gworld).portPixMap), &(*gWindow).portBits,
  531.             &(**(*gworld).portPixMap).bounds, &bounds, srcCopy, nil );*/
  532.     CopyBits( (BitMap *)(*(GetPortPixMap(gworld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  533.             &(**(GetPortPixMap(gworld))).bounds, &bounds, srcCopy, nil );
  534.     
  535.     DisposeGWorld( source );
  536.     DisposeGWorld( gworld );
  537. }
  538.  
  539. void customExample(Rect    * rect,int    item )
  540. {
  541.     #pragma unused(item)
  542.     int            transferMode;
  543.     int            ditherMode;
  544.     RGBColor    color;
  545.     ColorSearchUPP searchProcUPP=NewColorSearchProc(searchProc);
  546.         
  547.     transferMode = setTransferMode( settings.tItem );
  548.     ditherMode = setDitherMode( settings.dItem );
  549.     
  550.     if (settings.cItem == 1)
  551.     {
  552.         ForeColor( blackColor );
  553.         BackColor( whiteColor );
  554.     }
  555.     else if (settings.cItem == 2)
  556.     {
  557.         ForeColor( whiteColor );
  558.         BackColor( blackColor );
  559.     }
  560.     else if (settings.cItem == 3)
  561.     {
  562.         color.green = 0xffff;
  563.         color.red = color.blue = 0;
  564.         RGBForeColor( &color );
  565.         BackColor( whiteColor );
  566.     }
  567.     else if (settings.cItem == 4)
  568.     {
  569.         color.green = 0xffff;
  570.         color.red = color.blue = 0;
  571.         ForeColor( blackColor );
  572.         RGBBackColor( &color );
  573.     }
  574.     
  575.     
  576.     if (settings.mItem == 2)
  577.         AddSearch(searchProcUPP);
  578.     
  579.     
  580.     /*CopyBits( (BitMap *)(*(*gGWorld).portPixMap), &gWindow->portBits,
  581.                 &(**(*gGWorld).portPixMap).bounds, rect,
  582.                 transferMode + ditherMode, nil );*/
  583.     CopyBits( (BitMap *)(*(GetPortPixMap(gGWorld))), GetPortBitMapForCopyBits(GetWindowPort(gWindow)),
  584.                 &(**(GetPortPixMap(gGWorld))).bounds, rect,
  585.                 transferMode + ditherMode, nil );
  586.                 
  587.     if (settings.mItem == 2)
  588.         DelSearch(searchProcUPP);
  589. }
  590.  
  591. GrafPtr CreateGrafPort( Rect *bounds )    /* CreateGrafPort originally written by Forrest Tanaka. */
  592. {
  593.     GrafPtr    savedPort;        /* Saved GrafPtr for later restore. */
  594.     GrafPtr    newPort;        /* New GrafPort. */
  595.     Rect    localBounds;    /* Local copy of bounds. */
  596.     RgnHandle        rgnHandle = NewRgn();    // Used for carbonization
  597.  
  598.     GetPort( &savedPort );
  599.  
  600.     /* Set the top-left corner of bounds to (0,0). */
  601.     localBounds = *bounds;
  602.     OffsetRect( &localBounds, -bounds->left, -bounds->top );
  603.  
  604.     /* Allocate a new GrafPort. */
  605.     //newPort = (GrafPtr)NewPtrClear( sizeof( GrafPort ) );
  606.     newPort = CreateNewPort();
  607.     
  608.     if (newPort != nil)
  609.     {
  610.         /* Initialize the new port and make the current port. */
  611.         //OpenPort( newPort );
  612.         SetPort( newPort);
  613.  
  614.         /* Initialize and allocate the bitmap. */
  615.         /*newPort->portBits.bounds = localBounds;
  616.           newPort->portBits.rowBytes = ((localBounds.right + 15) >> 4) << 1;
  617.         newPort->portBits.baseAddr =  NewPtrClear( newPort->portBits.rowBytes *
  618.                                                     (long)localBounds.bottom );*/
  619.  
  620.         (*(GetPortPixMap(newPort)))->bounds = localBounds;
  621.         (*(GetPortPixMap(newPort)))->rowBytes = ((localBounds.right + 15) >> 4) <<1;
  622.         (*(GetPortPixMap(newPort)))->baseAddr = NewPtrClear(GetPortBitMapForCopyBits(newPort)->rowBytes *
  623.                                                         (long)localBounds.bottom );
  624.         
  625.         //if (newPort->portBits.baseAddr != nil)
  626.         if (GetPortBitMapForCopyBits(newPort)->baseAddr != nil)
  627.         {
  628.             /* Clean up the new port. */
  629.             //newPort->portRect = localBounds;
  630.             SetPortBounds(newPort, &localBounds);
  631.             ClipRect( &localBounds );
  632.             //RectRgn( newPort->visRgn, &localBounds );
  633.             RectRgn( GetPortVisibleRegion(newPort, rgnHandle), &localBounds );
  634.             EraseRect( &localBounds );
  635.         }
  636.         else
  637.         {
  638.             /* Allocation failed; deallocate the port. */
  639.             /*ClosePort( newPort );
  640.             DisposePtr( (Ptr)newPort );*/
  641.             DisposePort( newPort );
  642.             newPort = nil;
  643.         }
  644.     }
  645.     
  646.     DisposeRgn(rgnHandle);
  647.     SetPort( savedPort );
  648.     return newPort;
  649. }
  650.  
  651. void DisposeGrafPort( GrafPtr doomedPort )    /* DisposeGrafPort originally written by Forrest Tanaka. */
  652. {
  653.     //ClosePort( doomedPort );
  654.     //DisposePtr( doomedPort->portBits.baseAddr );
  655.     DisposePtr( GetPortBitMapForCopyBits(doomedPort)->baseAddr );
  656.     //DisposePtr( (Ptr)doomedPort );
  657.     DisposePort( doomedPort );
  658. }